home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / lalr.lha / lalr / m2c / Reduce.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  8KB  |  314 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Errors
  4. #include "Errors.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Sets
  8. #include "Sets.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Automaton
  12. #include "Automaton.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_TokenTab
  16. #include "TokenTab.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Idents
  20. #include "Idents.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Reduce
  24. #include "Reduce.h"
  25. #endif
  26.  
  27. BOOLEAN Reduce_Reduced;
  28.  
  29. #define eNotReach    47
  30. #define eNoProd    46
  31. #define eNotTerm    45
  32. static BOOLEAN TestReach ARGS((Sets_tSet reached));
  33. static BOOLEAN TestTerm ARGS((Sets_tSet reached));
  34. static void IsYetTerm ARGS((CARDINAL nt));
  35.  
  36. static Sets_tSet *G_1_todo;
  37. static Sets_tSet *G_2_done;
  38. static BOOLEAN *G_3_success;
  39.  
  40. void Reduce_TestReduced
  41. # ifdef __STDC__
  42. ()
  43. # else
  44. ()
  45. # endif
  46. {
  47.   BOOLEAN ok, okreach, okterm;
  48.   Sets_tSet reached;
  49.  
  50.   Sets_MakeSet(&reached, (LONGCARD)TokenTab_MAXNonTerm);
  51.   okreach = TestReach(reached);
  52.   okterm = TestTerm(reached);
  53.   ok = okterm;
  54.   Reduce_Reduced = ok;
  55.   Sets_ReleaseSet(&reached);
  56. }
  57.  
  58. static BOOLEAN TestReach
  59. # ifdef __STDC__
  60. (Sets_tSet reached)
  61. # else
  62. (reached)
  63. Sets_tSet reached;
  64. # endif
  65. {
  66.   BOOLEAN reach;
  67.   TokenTab_Terminal t;
  68.   TokenTab_NonTerminal nt;
  69.   Sets_tSet todo;
  70.   Sets_tSet done;
  71.   Automaton_tIndex u, i;
  72.   Automaton_tProdIndex pn;
  73.   Automaton_tProduction prod;
  74.   TokenTab_Vocabulary ri, voc;
  75.   TokenTab_TokenError error;
  76.   Idents_tIdent sym;
  77.   TokenTab_PosType pos;
  78.  
  79.   Sets_MakeSet(&todo, (LONGCARD)TokenTab_MAXNonTerm);
  80.   Sets_MakeSet(&done, (LONGCARD)TokenTab_MAXNonTerm);
  81.   Sets_Include(&todo, (LONGCARD)Automaton_StartSymbol);
  82.   Sets_Include(&reached, (LONGCARD)Automaton_StartSymbol);
  83.   {
  84.     TokenTab_Terminal B_1 = TokenTab_MINTerm, B_2 = TokenTab_MAXTerm;
  85.  
  86.     if (B_1 <= B_2)
  87.       for (t = B_1;; t += 1) {
  88.         if (TokenTab_GetTokenType(t) == TokenTab_Term) {
  89.           Sets_Include(&done, (LONGCARD)t);
  90.         }
  91.         if (t >= B_2) break;
  92.       }
  93.   }
  94.   do {
  95.     nt = Sets_Extract(&todo);
  96.     Sets_Include(&done, (LONGCARD)nt);
  97.     {
  98.       register Automaton_tProdIndexList *W_1 = &Automaton_ProdList.A[nt - 1001];
  99.  
  100.       u = W_1->Used;
  101.       {
  102.         Automaton_tProdIndex B_3 = 1, B_4 = u;
  103.  
  104.         if (B_3 <= B_4)
  105.           for (pn = B_3;; pn += 1) {
  106.             prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_1->Array->A[pn - 1].Index]);
  107.             {
  108.               register struct Automaton_9 *W_2 = prod;
  109.  
  110.               {
  111.                 LONGCARD B_5 = 1, B_6 = W_2->Len;
  112.  
  113.                 if (B_5 <= B_6)
  114.                   for (i = B_5;; i += 1) {
  115.                     ri = W_2->Right.A[i - 1];
  116.                     Sets_Include(&reached, (LONGCARD)ri);
  117.                     if (!Sets_IsElement((LONGCARD)ri, &done)) {
  118.                       Sets_Include(&todo, (LONGCARD)ri);
  119.                     }
  120.                     if (i >= B_6) break;
  121.                   }
  122.               }
  123.             }
  124.             if (pn >= B_4) break;
  125.           }
  126.       }
  127.     }
  128.   } while (!Sets_IsEmpty(todo));
  129.   reach = TRUE;
  130.   {
  131.     TokenTab_Vocabulary B_7 = TokenTab_MINTerm, B_8 = TokenTab_MAXTerm;
  132.  
  133.     if (B_7 <= B_8)
  134.       for (voc = B_7;; voc += 1) {
  135.         if (TokenTab_GetTokenType(voc) != TokenTab_None && !Sets_IsElement((LONGCARD)voc, &reached)) {
  136.           TokenTab_GetTokenPos(voc, &pos);
  137.           sym = TokenTab_TokenToSymbol(voc, &error);
  138.           Errors_ErrorMessageI((LONGCARD)eNotReach, (LONGCARD)Errors_eWarning, pos, (LONGCARD)Errors_eIdent, ADR(sym));
  139.         }
  140.         if (voc >= B_8) break;
  141.       }
  142.   }
  143.   {
  144.     TokenTab_Vocabulary B_9 = TokenTab_MINNonTerm, B_10 = TokenTab_MAXNonTerm;
  145.  
  146.     if (B_9 <= B_10)
  147.       for (voc = B_9;; voc += 1) {
  148.         if (TokenTab_GetTokenType(voc) != TokenTab_None && !Sets_IsElement((LONGCARD)voc, &reached)) {
  149.           TokenTab_GetTokenPos(voc, &pos);
  150.           sym = TokenTab_TokenToSymbol(voc, &error);
  151.           Errors_ErrorMessageI((LONGCARD)eNotReach, (LONGCARD)Errors_eWarning, pos, (LONGCARD)Errors_eIdent, ADR(sym));
  152.           reach = FALSE;
  153.         }
  154.         if (voc >= B_10) break;
  155.       }
  156.   }
  157.   Sets_ReleaseSet(&todo);
  158.   Sets_ReleaseSet(&done);
  159.   return reach;
  160. }
  161.  
  162. static void IsYetTerm
  163. # ifdef __STDC__
  164. (CARDINAL nt)
  165. # else
  166. (nt)
  167. CARDINAL nt;
  168. # endif
  169. {
  170.   Automaton_tIndex u, i;
  171.   Automaton_tProdIndex pn;
  172.   Automaton_tProduction prod;
  173.   TokenTab_Vocabulary ri;
  174.   TokenTab_Terminal t;
  175.   BOOLEAN localsuccess;
  176.  
  177.   {
  178.     register Automaton_tProdIndexList *W_3 = &Automaton_ProdList.A[nt - 1001];
  179.  
  180.     u = W_3->Used;
  181.     localsuccess = FALSE;
  182.     pn = 1;
  183.     while (pn <= u && !localsuccess) {
  184.       prod = (Automaton_tProduction)ADR(Automaton_ProdArrayPtr->A[W_3->Array->A[pn - 1].Index]);
  185.       {
  186.         register struct Automaton_9 *W_4 = prod;
  187.  
  188.         localsuccess = TRUE;
  189.         i = 1;
  190.         while (i <= W_4->Len && localsuccess) {
  191.           ri = W_4->Right.A[i - 1];
  192.           localsuccess = Sets_IsElement((LONGCARD)ri, G_2_done);
  193.           INC(i);
  194.         }
  195.       }
  196.       INC(pn);
  197.     }
  198.   }
  199.   if (localsuccess) {
  200.     Sets_Include(G_2_done, nt);
  201.     Sets_Exclude(G_1_todo, nt);
  202.     *G_3_success = TRUE;
  203.   }
  204. }
  205.  
  206. static BOOLEAN TestTerm
  207. # ifdef __STDC__
  208. (Sets_tSet reached)
  209. # else
  210. (reached)
  211. Sets_tSet reached;
  212. # endif
  213. {
  214.   Sets_tSet todo;
  215.   Sets_tSet done;
  216.   BOOLEAN success;
  217.   TokenTab_Terminal t;
  218.   TokenTab_NonTerminal nt;
  219.   BOOLEAN term;
  220.   TokenTab_TokenError error;
  221.   Idents_tIdent sym;
  222.   TokenTab_PosType pos;
  223.   CARDINAL kind;
  224.   Sets_tSet *L_1;
  225.   Sets_tSet *L_2;
  226.   BOOLEAN *L_3;
  227.  
  228.   L_1 = G_1_todo;
  229.   G_1_todo = &todo;
  230.   L_2 = G_2_done;
  231.   G_2_done = &done;
  232.   L_3 = G_3_success;
  233.   G_3_success = &success;
  234.   Sets_MakeSet(&todo, (LONGCARD)TokenTab_MAXNonTerm);
  235.   Sets_MakeSet(&done, (LONGCARD)TokenTab_MAXNonTerm);
  236.   {
  237.     TokenTab_NonTerminal B_11 = TokenTab_MINNonTerm, B_12 = TokenTab_MAXNonTerm;
  238.  
  239.     if (B_11 <= B_12)
  240.       for (nt = B_11;; nt += 1) {
  241.         if (TokenTab_GetTokenType(nt) == TokenTab_NonTerm) {
  242.           Sets_Include(&todo, (LONGCARD)nt);
  243.         }
  244.         if (nt >= B_12) break;
  245.       }
  246.   }
  247.   {
  248.     TokenTab_Terminal B_13 = TokenTab_MINTerm, B_14 = TokenTab_MAXTerm;
  249.  
  250.     if (B_13 <= B_14)
  251.       for (t = B_13;; t += 1) {
  252.         if (TokenTab_GetTokenType(t) == TokenTab_Term) {
  253.           Sets_Include(&done, (LONGCARD)t);
  254.         }
  255.         if (t >= B_14) break;
  256.       }
  257.   }
  258.   do {
  259.     success = FALSE;
  260.     {
  261.       TokenTab_NonTerminal B_15 = TokenTab_MINNonTerm, B_16 = TokenTab_MAXNonTerm;
  262.  
  263.       if (B_15 <= B_16)
  264.         for (nt = B_15;; nt += 1) {
  265.           if (Sets_IsElement((LONGCARD)nt, &todo)) {
  266.             IsYetTerm((LONGCARD)nt);
  267.           }
  268.           if (nt >= B_16) break;
  269.         }
  270.     }
  271.   } while (!!success);
  272.   term = TRUE;
  273.   if (!Sets_IsEmpty(todo)) {
  274.     do {
  275.       nt = Sets_Extract(&todo);
  276.       if (Sets_IsElement((LONGCARD)nt, &reached)) {
  277.         term = FALSE;
  278.         kind = Errors_eError;
  279.       } else {
  280.         kind = Errors_eWarning;
  281.       }
  282.       TokenTab_GetTokenPos(nt, &pos);
  283.       sym = TokenTab_TokenToSymbol(nt, &error);
  284.       if (Automaton_ProdList.A[nt - 1001].Used == 0) {
  285.         Errors_ErrorMessageI((LONGCARD)eNoProd, kind, pos, (LONGCARD)Errors_eIdent, ADR(sym));
  286.       } else {
  287.         Errors_ErrorMessageI((LONGCARD)eNotTerm, kind, pos, (LONGCARD)Errors_eIdent, ADR(sym));
  288.       }
  289.     } while (!Sets_IsEmpty(todo));
  290.   }
  291.   Sets_ReleaseSet(&todo);
  292.   Sets_ReleaseSet(&done);
  293.   G_1_todo = L_1;
  294.   G_2_done = L_2;
  295.   G_3_success = L_3;
  296.   return term;
  297. }
  298.  
  299. void BEGIN_Reduce()
  300. {
  301.   static BOOLEAN has_been_called = FALSE;
  302.  
  303.   if (!has_been_called) {
  304.     has_been_called = TRUE;
  305.  
  306.     BEGIN_Errors();
  307.     BEGIN_Sets();
  308.     BEGIN_Automaton();
  309.     BEGIN_TokenTab();
  310.     BEGIN_Idents();
  311.  
  312.   }
  313. }
  314.